home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / kernel / fspdev / fspdevInt.h < prev    next >
Encoding:
C/C++ Source or Header  |  1992-12-19  |  14.0 KB  |  326 lines
  1. /*
  2.  * fspdevInt.h --
  3.  *
  4.  *    Declarations for pseudo-devices and pseudo-filesystems.
  5.  *
  6.  *    A pseudo-device is a file that acts as a communication channel
  7.  *    between a user-level server process (hereafter called the "server"),
  8.  *    and one or more client processes (hereafter called the "clients").
  9.  *    Regular filesystem system calls (Fs_Read, Fs_Write, Fs_IOControl,
  10.  *    Fs_Close) by a client process are forwarded to the server using
  11.  *    a request-response procotol.  The server process can implement any
  12.  *    sort of sementics for the file operations it wants to. The general
  13.  *    format of Fs_IOControl, in particular, lets the server implement
  14.  *    any remote procedure call it cares to define.
  15.  *
  16.  *    A pseudo-filesystem is a whole sub-tree of the filesystem that
  17.  *    is controlled by a user-level server process.  The basic request
  18.  *    response protocol is still used for communication.  In addition to
  19.  *    file access operations, file naming operations are handled by
  20.  *    a pseudo-filesystem server.  The pseudo-filesystem server can
  21.  *    establish pseudo-device like connections for each pseudo-file
  22.  *    that is opened, or it can open regular files and connect its
  23.  *    clients to those files instead.
  24.  *
  25.  *    The user include file <dev/pdev.h> defines the request-response
  26.  *    protocol as viewed by the user-level server process.
  27.  *
  28.  *      The handle definitions have been moved to fspdev.h   JMS
  29.  *
  30.  * Copyright 1987 Regents of the University of California
  31.  * All rights reserved.
  32.  *
  33.  *
  34.  * $Header: /cdrom/src/kernel/Cvsroot/kernel/fspdev/fspdevInt.h,v 9.7 92/10/26 14:05:48 mgbaker Exp $ SPRITE (Berkeley)
  35.  */
  36.  
  37. #ifndef _FSPDEVINT
  38. #define _FSPDEVINT
  39.  
  40. #include <trace.h>
  41. #include <dev/pdev.h>
  42. #include <dev/pfs.h>
  43. #include <fsioLock.h>
  44. #include <fspdev.h>
  45.  
  46. #include <stdio.h>
  47.  
  48. /*
  49.  * Because there are corresponding control handles on the file server,
  50.  * which records which host has the pdev server, and on the pdev server
  51.  * itself, we need to be able to reopen the control handle on the
  52.  * file server after it reboots.
  53.  */
  54. typedef struct FspdevControlReopenParams {
  55.     Fs_FileID    fileID;        /* FileID of the control handle */
  56.     int        serverID;    /* ServerID recorded in control handle.
  57.                  * This may be NIL if the server closes
  58.                  * while the file server is down. */
  59.     int        seed;        /* Used to create unique pseudo-stream fileIDs*/
  60. } FspdevControlReopenParams;
  61.  
  62. /*
  63.  * The following control messages are passed internally from the
  64.  * ServerStreamCreate routine to the FspdevControlRead routine.
  65.  * They contain a streamPtr for a new server stream
  66.  * that gets converted to a user-level streamID in FspdevControlRead.
  67.  */
  68.  
  69. typedef struct FspdevNotify {
  70.     List_Links links;
  71.     Fs_Stream *streamPtr;
  72. } FspdevNotify;
  73.  
  74. #define PDEV_REQUEST_PRINT(fileIDPtr, requestHdrPtr) \
  75.     switch(requestHdrPtr->operation) {  \
  76.         case PDEV_OPEN: \
  77.             DBG_PRINT( ("Pdev %d,%d: Open  ", (fileIDPtr)->major, \
  78.                                              (fileIDPtr)->minor) ); \
  79.             break;      \
  80.         case PDEV_READ: \
  81.             DBG_PRINT( ("Pdev %d,%d: Read  ", (fileIDPtr)->major, \
  82.                                              (fileIDPtr)->minor) ); \
  83.             break;      \
  84.         case PDEV_WRITE:        \
  85.             DBG_PRINT( ("Pdev %d,%d: Write ", (fileIDPtr)->major, \
  86.                                              (fileIDPtr)->minor) ); \
  87.             break;      \
  88.         case PDEV_CLOSE:        \
  89.             DBG_PRINT( ("Pdev %d,%d: Close ", (fileIDPtr)->major, \
  90.                                              (fileIDPtr)->minor) ); \
  91.             break;      \
  92.         case PDEV_IOCTL:        \
  93.             DBG_PRINT( ("Pdev %d,%d: Ioctl ", (fileIDPtr)->major, \
  94.                                              (fileIDPtr)->minor) ); \
  95.             break;      \
  96.         default:        \
  97.             DBG_PRINT( ("Pdev %d,%d: ?!?   ", (fileIDPtr)->major, \
  98.                                              (fileIDPtr)->minor) ); \
  99.             break;      \
  100.     }
  101.  
  102. /*
  103.  * These are the trace macros left over from -DCLEAN.  We no longer have
  104.  * pdev tracing, but some folks find it useful to see the macro calls in
  105.  * the code, so we're leaving those there and thus these empty defitions
  106.  * here.
  107.  */
  108. #define DBG_PRINT(fmt)
  109.  
  110. #define PDEV_TRACE(fileIDPtr, event)
  111. #define PDEV_REQUEST(fileIDPtr, requestHdrPtr)
  112. #define PDEV_REPLY(fileIDPtr, replyPtr)
  113. #define PDEV_TSELECT(fileIDPtr, read, write, except)
  114. #define PDEV_WAKEUP(fileIDPtr, waitInfoPtr, selectBits)
  115.  
  116. /*
  117.  * Internal Pdev routines
  118.  */
  119. extern ReturnStatus FspdevSignalOwner _ARGS_((
  120.         Fspdev_ControlIOHandle *ctrlHandlePtr, Fs_IOCParam *ioctlPtr));
  121. extern Fspdev_ClientIOHandle *FspdevConnect _ARGS_((
  122.         Fspdev_ControlIOHandle *ctrlHandlePtr, Fs_FileID *ioFileIDPtr,
  123.         int clientID, Boolean naming));
  124.  
  125. /*
  126.  * File server open-time routines.
  127.  */
  128. extern ReturnStatus FspdevNameOpen _ARGS_((Fsio_FileIOHandle *handlePtr,
  129.         Fs_OpenArgs *openArgsPtr, Fs_OpenResults *openResultsPtr));
  130. extern ReturnStatus FspdevRmtLinkNameOpen _ARGS_((Fsio_FileIOHandle *handlePtr,
  131.         Fs_OpenArgs *openArgsPtr, Fs_OpenResults *openResultsPtr));
  132. /*
  133.  * Control Stream routines.
  134.  */
  135. extern Fspdev_ControlIOHandle *FspdevControlHandleInit _ARGS_((
  136.         Fs_FileID *fileIDPtr, char *name));
  137. extern ReturnStatus FspdevControlIoOpen _ARGS_((Fs_FileID *ioFileIDPtr, 
  138.         int *flagsPtr, int clientID, ClientData streamData, char *name,
  139.         Fs_HandleHeader **ioHandlePtrPtr));
  140. extern ReturnStatus FspdevControlSelect _ARGS_((Fs_HandleHeader *hdrPtr, 
  141.         Sync_RemoteWaiter *waitPtr, int *readPtr, int *writePtr, 
  142.         int *exceptPtr));
  143. extern ReturnStatus FspdevControlRead _ARGS_((Fs_Stream *streamPtr, 
  144.         Fs_IOParam *readPtr, Sync_RemoteWaiter *waitPtr, 
  145.         Fs_IOReply *replyPtr));
  146. extern ReturnStatus FspdevControlIOControl _ARGS_((Fs_Stream *streamPtr, 
  147.         Fs_IOCParam *ioctlPtr, Fs_IOReply *replyPtr));
  148. extern ReturnStatus FspdevControlGetIOAttr _ARGS_((Fs_FileID *fileIDPtr, 
  149.         int clientID, Fs_Attributes *attrPtr));
  150. extern ReturnStatus FspdevControlSetIOAttr _ARGS_((Fs_FileID *fileIDPtr, 
  151.         Fs_Attributes *attrPtr, int flags));
  152. extern Fs_HandleHeader *FspdevControlVerify _ARGS_((Fs_FileID *fileIDPtr, 
  153.         int pdevServerHostID, int *domainTypePtr));
  154. extern ReturnStatus FspdevControlReopen _ARGS_((Fs_HandleHeader *hdrPtr,
  155.         int clientID, ClientData inData, int *outSizePtr, 
  156.         ClientData *outDataPtr));
  157. extern ReturnStatus FspdevSetupControlReopen _ARGS_((Fs_HandleHeader *hdrPtr,
  158.         Address paramsPtr));
  159. extern void FspdevFinishControlReopen _ARGS_((Fs_HandleHeader *hdrPtr,
  160.         Address statePtr, ReturnStatus status));
  161. extern ReturnStatus FspdevControlClose _ARGS_((Fs_Stream *streamPtr, 
  162.         int clientID, Proc_PID procID, int flags, int size,
  163.         ClientData data));
  164. extern void FspdevControlClientKill _ARGS_((Fs_HandleHeader *hdrPtr,
  165.         int clientID));
  166. extern Boolean FspdevControlScavenge _ARGS_((Fs_HandleHeader *hdrPtr));
  167. /*
  168.  * Pfs Control Stream routines.
  169.  */
  170. extern ReturnStatus FspdevPfsIoOpen _ARGS_((Fs_FileID *ioFileIDPtr,
  171.         int *flagsPtr, int clientID, ClientData streamData,
  172.         char *name, Fs_HandleHeader **ioHandlePtrPtr));
  173. /*
  174.  * Server stream routines.
  175.  */
  176. extern ReturnStatus FspdevServerStreamSelect _ARGS_((Fs_HandleHeader *hdrPtr,
  177.         Sync_RemoteWaiter *waitPtr, int *readPtr, int *writePtr, 
  178.         int *exceptPtr));
  179. extern ReturnStatus FspdevServerStreamRead _ARGS_((Fs_Stream *streamPtr, 
  180.         Fs_IOParam *readPtr, Sync_RemoteWaiter *waitPtr,
  181.         Fs_IOReply *replyPtr));
  182. extern ReturnStatus FspdevServerStreamIOControl _ARGS_((Fs_Stream *streamPtr, 
  183.         Fs_IOCParam *ioctlPtr, Fs_IOReply *replyPtr));
  184. extern ReturnStatus FspdevServerStreamClose _ARGS_((Fs_Stream *streamPtr, 
  185.         int clientID, Proc_PID procID, int flags, int size, 
  186.         ClientData data));
  187. /*
  188.  * Pseudo-device (client-side) streams
  189.  */
  190. extern ReturnStatus FspdevPseudoStreamIoOpen _ARGS_(( Fs_FileID *ioFileIDPtr,
  191.         int *flagsPtr, int clientID, ClientData streamData, char *name,
  192.         Fs_HandleHeader **ioHandlePtrPtr));
  193. extern ReturnStatus FspdevPseudoStreamOpen _ARGS_((
  194.         Fspdev_ServerIOHandle *pdevHandlePtr, int flags, int clientID, 
  195.         Proc_PID procID, int userID));
  196. extern ReturnStatus FspdevPseudoStreamRead _ARGS_((Fs_Stream *streamPtr, 
  197.         Fs_IOParam *readPtr, Sync_RemoteWaiter *waitPtr, 
  198.         Fs_IOReply *replyPtr));
  199. extern ReturnStatus FspdevPseudoStreamWrite _ARGS_((Fs_Stream *streamPtr, 
  200.         Fs_IOParam *writePtr, Sync_RemoteWaiter *waitPtr, 
  201.         Fs_IOReply *replyPtr));
  202. extern ReturnStatus FspdevPseudoStreamIOControl _ARGS_((Fs_Stream *streamPtr, 
  203.         Fs_IOCParam *ioctlPtr, Fs_IOReply *replyPtr));
  204. extern ReturnStatus FspdevPseudoStreamSelect _ARGS_((Fs_HandleHeader *hdrPtr,
  205.         Sync_RemoteWaiter *waitPtr, int *readPtr, int *writePtr,
  206.         int *exceptPtr));
  207. extern ReturnStatus FspdevPseudoStreamGetIOAttr _ARGS_((Fs_FileID *fileIDPtr, 
  208.         int clientID,   Fs_Attributes *attrPtr));
  209. extern ReturnStatus FspdevPseudoStreamSetIOAttr _ARGS_((Fs_FileID *fileIDPtr,
  210.         Fs_Attributes *attrPtr, int flags));
  211. extern ReturnStatus FspdevPseudoStreamMigClose _ARGS_((Fs_HandleHeader *hdrPtr,
  212.         int flags));
  213. extern ReturnStatus FspdevPseudoStreamMigrate _ARGS_((Fsio_MigInfo *migInfoPtr,
  214.         int dstClientID, int *flagsPtr, int *offsetPtr, int *sizePtr,
  215.         Address *dataPtr));
  216. extern ReturnStatus FspdevPseudoStreamMigOpen _ARGS_((Fsio_MigInfo *migInfoPtr,
  217.         int size, ClientData data, Fs_HandleHeader **hdrPtrPtr));
  218. extern ReturnStatus FspdevPseudoStreamClose _ARGS_((Fs_Stream *streamPtr, 
  219.         int clientID, Proc_PID procID, int flags, int size,
  220.         ClientData data));
  221. extern void FspdevPseudoStreamCloseInt _ARGS_((    
  222.         Fspdev_ServerIOHandle *pdevHandlePtr));
  223.  
  224. extern Fspdev_ServerIOHandle *FspdevServerStreamCreate _ARGS_((
  225.         Fs_FileID *ioFileIDPtr, char *name, Boolean naming));
  226.  
  227. /*
  228.  * Remote pseudo-device streams
  229.  */
  230. extern ReturnStatus FspdevRmtPseudoStreamIoOpen _ARGS_((Fs_FileID *ioFileIDPtr,
  231.         int *flagsPtr, int clientID, ClientData streamData, char *name,
  232.         Fs_HandleHeader **ioHandlePtrPtr));
  233. extern Fs_HandleHeader *FspdevRmtPseudoStreamVerify _ARGS_((
  234.         Fs_FileID *fileIDPtr, int clientID, int *domainTypePtr));
  235. extern ReturnStatus FspdevRmtPseudoStreamMigrate _ARGS_((
  236.         Fsio_MigInfo *migInfoPtr, int dstClientID, int *flagsPtr,
  237.         int *offsetPtr, int *sizePtr, Address *dataPtr));
  238. extern ReturnStatus FspdevRmtPseudoStreamClose _ARGS_((Fs_Stream *streamPtr, 
  239.         int clientID, Proc_PID procID, int flags, int size,
  240.         ClientData data));
  241. /*
  242.  * Local and remote pseudo-device streams to pseudo-file-systems
  243.  */
  244. extern ReturnStatus FspdevPfsStreamIoOpen _ARGS_((Fs_FileID *ioFileIDPtr, 
  245.         int *flagsPtr, int clientID, ClientData streamData, char *name,
  246.         Fs_HandleHeader **ioHandlePtrPtr));
  247. extern ReturnStatus FspdevRmtPfsStreamIoOpen _ARGS_((Fs_FileID *ioFileIDPtr, 
  248.         int *flagsPtr, int clientID, ClientData streamData, char *name,
  249.         Fs_HandleHeader **ioHandlePtrPtr));
  250. /*
  251.  * Naming Stream routines.
  252.  */
  253. extern ReturnStatus FspdevPfsExport _ARGS_((Fs_HandleHeader *hdrPtr,
  254.         int clientID, register Fs_FileID *ioFileIDPtr, 
  255.         int *dataSizePtr, ClientData *clientDataPtr));
  256. extern ReturnStatus FspdevPfsNamingIoOpen _ARGS_((Fs_FileID *ioFileIDPtr,
  257.         int *flagsPtr, int clientID, ClientData streamData, char *name,
  258.         Fs_HandleHeader **ioHandlePtrPtr));
  259. /*
  260.  * Pseudo-file-system naming routines.
  261.  */
  262. extern ReturnStatus FspdevPfsOpen _ARGS_((Fs_HandleHeader *prefixHandle,
  263.         char *relativeName, Address argsPtr, Address resultsPtr, 
  264.         Fs_RedirectInfo **newNameInfoPtrPtr));
  265. extern ReturnStatus FspdevPfsGetAttrPath _ARGS_((Fs_HandleHeader *prefixHandle,
  266.         char *relativeName, Address argsPtr, Address resultsPtr, 
  267.         Fs_RedirectInfo **newNameInfoPtrPtr));
  268. extern ReturnStatus FspdevPfsSetAttrPath _ARGS_((Fs_HandleHeader *prefixHandle,
  269.         char *relativeName, Address argsPtr, Address resultsPtr,
  270.         Fs_RedirectInfo **newNameInfoPtrPtr));
  271. extern ReturnStatus FspdevPfsMakeDir _ARGS_((Fs_HandleHeader *prefixHandle,
  272.         char *relativeName, Address argsPtr, Address resultsPtr,
  273.         Fs_RedirectInfo **newNameInfoPtrPtr));
  274. extern ReturnStatus FspdevPfsMakeDevice _ARGS_((Fs_HandleHeader *prefixHandle, 
  275.         char *relativeName, Address argsPtr, Address resultsPtr,
  276.         Fs_RedirectInfo **newNameInfoPtrPtr));
  277. extern ReturnStatus FspdevPfsRemove _ARGS_((Fs_HandleHeader *prefixHandle,
  278.         char *relativeName, Address argsPtr, Address resultsPtr,
  279.         Fs_RedirectInfo **newNameInfoPtrPtr));
  280. extern ReturnStatus FspdevPfsRemoveDir _ARGS_((Fs_HandleHeader *prefixHandle,
  281.         char *relativeName, Address argsPtr, Address resultsPtr, 
  282.         Fs_RedirectInfo **newNameInfoPtrPtr));
  283. extern ReturnStatus FspdevPfsRename _ARGS_((Fs_HandleHeader *prefixHandle1,
  284.         char *relativeName1, Fs_HandleHeader *prefixHandle2,
  285.         char *relativeName2, Fs_LookupArgs *lookupArgsPtr, 
  286.         Fs_RedirectInfo **newNameInfoPtrPtr, Boolean *name1ErrorPtr));
  287. extern ReturnStatus FspdevPfsHardLink _ARGS_((Fs_HandleHeader *prefixHandle1,
  288.         char *relativeName1, Fs_HandleHeader *prefixHandle2,
  289.         char *relativeName2, Fs_LookupArgs *lookupArgsPtr, 
  290.         Fs_RedirectInfo **newNameInfoPtrPtr, Boolean *name1ErrorPtr));
  291. extern ReturnStatus FspdevPfs2Path _ARGS_((Pdev_Op operation, 
  292.         Fs_HandleHeader *prefixHandle1, char *relativeName1, 
  293.         Fs_HandleHeader *prefixHandle2, char *relativeName2,
  294.         Fs_LookupArgs *lookupArgsPtr, 
  295.         Fs_RedirectInfo **newNameInfoPtrPtr, Boolean *name1ErrorPtr));
  296. extern ReturnStatus FspdevPseudoStream2Path _ARGS_((
  297.         Fspdev_ServerIOHandle *pdevHandlePtr, Pfs_Request *requestPtr,
  298.         Fs_2PathData *dataPtr, Boolean *name1ErrorPtr, 
  299.         Fs_RedirectInfo **newNameInfoPtrPtr));
  300.  
  301. extern ReturnStatus FspdevPseudoStreamLookup _ARGS_((
  302.         Fspdev_ServerIOHandle *pdevHandlePtr, Pfs_Request *requestPtr,
  303.         int argSize, Address argsPtr, int *resultsSizePtr, 
  304.         Address resultsPtr, Fs_RedirectInfo **newNameInfoPtrPtr));
  305.  
  306. /*
  307.  * Pseudo-file-system routines given an open file.
  308.  */
  309. extern ReturnStatus FspdevPseudoGetAttr _ARGS_((Fs_FileID *fileIDPtr, 
  310.         int clientID, Fs_Attributes *attrPtr));
  311. extern ReturnStatus FspdevPseudoSetAttr _ARGS_((Fs_FileID *fileIDPtr, 
  312.         Fs_Attributes *attrPtr, Fs_UserIDs *idPtr, int flags));
  313.  
  314. extern Boolean FspdevPdevServerOK _ARGS_((Fspdev_ServerIOHandle *pdevHandlePtr));
  315.  
  316. extern ReturnStatus FspdevPassStream _ARGS_((Fs_FileID *ioFileIDPtr,
  317.         int *flagsPtr, int clientID, ClientData streamData, 
  318.         char *name, Fs_HandleHeader **ioHandlePtrPtr));
  319.  
  320.  
  321. extern int FspdevPfsOpenConnection _ARGS_((
  322.         Fspdev_ServerIOHandle *namingPdevHandlePtr, 
  323.         Fs_FileID *srvrFileIDPtr, Fs_OpenResults *openResultsPtr));
  324.  
  325. #endif _FSPDEVINT
  326.